﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Proxy;
using SIM.Geo.UI.Movil.Clases;
using SIM.Geo.UI.Movil.Clases.DTO;
using SIM.Util;
using System.Text;

namespace SIM.Geo.UI.Movil.Controllers
{
    public class EstructuraController : BaseController
    {
        //GET: /Estructura/
        List<EstructuraTipoRellenoResponse> listaTipoRelleno = new List<EstructuraTipoRellenoResponse>();
        private const string SESSION_ESTRUCTURAS = "Tipo_Relleno";

        //private UsuarioResponse Usuario
        //{
        //    get { return (UsuarioResponse)Session[Sesiones.USUARIO]; }
        //}
        
        public JsonResult CerrarPopUp()
        {
            Session.Remove(SESSION_ESTRUCTURAS);
            return Json(new Resultado() { result = 1, message = "OK" }, JsonRequestBehavior.AllowGet);
        }
        public ActionResult Index(int idSondaje)
        {
            Session.Remove(SESSION_ESTRUCTURAS);
            return View();
        }

        public JsonResult Listar(int idSondaje)
        {
            using (SEEstructuraClient proxy = new SEEstructuraClient())
            {
                var lista = proxy.BuscarEstructuraPorSondaje1(idSondaje);
                return Json(lista, JsonRequestBehavior.AllowGet);
            }
        }

        //Generar codigo muestra sondaje

        //GET : /Estructura/DETAILS/
        public ActionResult Details(int id)
        {

            return View();
        }

        //GET: /estructura/Create

        public ActionResult Create()
        {

            return View();
            //return View();
        }

        /// <summary>
        /// Validación unica para insertar y modificar
        /// Agregado: por Edgar
        /// </summary>
        /// <param name="entidad"></param>
        /// <param name="sb"></param>
        /// <returns></returns>
        private bool Validar(Estructura entidad, ref  StringBuilder sb)
        {
            bool retorno = true;
            try
            {
                if (entidad.Desde >= entidad.Hasta)
                {
                    sb.AppendLine(Constantes.MensajeGenerico.MSG_VALIDA_RANGO);
                    retorno = false;
                }
                if (entidad.CodigoTipoEstructura == 0)
                {
                    sb.AppendLine(Constantes.MensajeEstructura.MSG_SELE_ESTRUCTURA);
                    retorno = false;
                }
                if (entidad.Angulo <= 0)
                {
                    sb.AppendLine(Constantes.MensajeEstructura.MSG_VALIDA_ANGULO);
                    retorno = false;
                }

                //si existen tipos rellenos agregados
                listaTipoRelleno = (List<EstructuraTipoRellenoResponse>)Session[SESSION_ESTRUCTURAS];
                if ((listaTipoRelleno == null || listaTipoRelleno.Count == 0))
                {
                    sb.AppendLine(Constantes.MensajeEstructura.MSG_VALIDA_RELLENO);
                    retorno = false;
                }

                //Valido las intersecciones
                using (var proxy = new SEEstructuraClient("BasicHttpBinding_ISEEstructura"))
                {
                    int resultInterseccion = proxy.ValidarInterseccionEstructura(entidad.CodigoSondaje, entidad.CodigoEstructura, entidad.Desde, entidad.Hasta);
                    if (resultInterseccion == 1)
                    {
                        sb.AppendLine("Existen intersección en las estruturas.");
                        retorno = false;
                    }
                }
            }
            catch (Exception ex)
            {
                retorno = false;
                
                Logger.Error("Estructura Controller:Validar", UserLogon.CodigoUsuario, ex);
            }
            return retorno;
        }

        //POST: //Estructura /Create
        /// <summary>
        /// metodo para guardar registro estructura
        /// </summary>
        /// <param name="entidad"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult Create(Estructura entidad)
        {
            Resultado retorno = new Resultado();
            try
            {
                bool flag_exito = true;

                //Modificado por Edgar, la validación debe ser unico para insertar y modificar
                StringBuilder sb = new StringBuilder();
                if (!this.Validar(entidad, ref sb))
                {
                    retorno.result = 0;
                    retorno.message = sb.ToString();
                    flag_exito = false;
                }

                //Fin de validación

                if (flag_exito)
                {
                    var estructura = entidad;
                    using (var proxy = new SEEstructuraClient())
                    {
                        estructura.CodigoGeologo = UserLogon.CodigoGeologo;//Usuario.CodigoGeologo;

                        listaTipoRelleno = (List<EstructuraTipoRellenoResponse>)Session[SESSION_ESTRUCTURAS];
                        if (listaTipoRelleno != null && listaTipoRelleno.Count > 0)
                        {

                            List<EstructuraTipoRelleno> listTipoRellenoEstructura = new List<EstructuraTipoRelleno>();
                            foreach (EstructuraTipoRellenoResponse item in listaTipoRelleno)
                            {
                                listTipoRellenoEstructura.Add(new EstructuraTipoRelleno
                                {
                                    CodigoEstructura = item.CodigoEstructura,
                                    CodigoSondaje = item.CodigoSondaje,
                                    CodigoTipoRelleno = item.CodigoTipoRelleno,
                                    Orden = item.Orden
                                });
                            }

                            estructura.EstructuraTipoRelleno = listTipoRellenoEstructura.ToArray();
                        }


                        //Modificado por Edgar, el resultado verifica si todo está ok
                        string result = proxy.InsertarEstructura(estructura);
                        if (result.CompareTo("Registrado") != 0)
                        {
                            retorno.result = 0;
                            //retorno.message = Constantes.MensajeEstructura.MSG_INSERT_NO_OK;
                            retorno.message = result;
                            flag_exito = false;
                        }
                        else
                        {
                            retorno.result = 1;
                            retorno.message = Constantes.MensajeEstructura.MSG_INSERT_OK;
                        }
                    }
                }

                //fin de validaciones insert

            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = String.Format("Ocurrió un Error: {0}", ex.Message);
                Logger.Error("Estructura Controller:Create", UserLogon.CodigoUsuario, ex);
            }
            return Json(retorno, JsonRequestBehavior.AllowGet);
        }

        //GET: /Estructura/Edit/5
        /// <summary>
        /// metodo obtener el registro de esctructura
        /// </summary>
        /// <param name="idSondaje"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public JsonResult Edit(int idSondaje, int id)
        {
            Resultado retorno = new Resultado();
            // Sondaje obj=null;
            try
            {
                //codigo muestra
                using (var proxy = new SEEstructuraClient())
                {
                    var obj = proxy.ObtenerEstructura(idSondaje, id);
                    if (obj != null)
                    {
                        using (var proxyGeo = new SEGeologoClient())
                        {
                            obj.Geologo = proxyGeo.ObtenerGeologo(obj.CodigoGeologo);
                        }
                    }
                    //Obtengo los detalles tipo relleno
                    if (obj != null && obj.EstructuraTipoRelleno != null)
                    {

                        List<EstructuraTipoRellenoResponse> listTipoRellenoEstructura = new List<EstructuraTipoRellenoResponse>();
                        foreach (EstructuraTipoRelleno item in obj.EstructuraTipoRelleno)
                        {


                            listTipoRellenoEstructura.Add(new EstructuraTipoRellenoResponse
                            {
                                CodigoEstructura = item.CodigoEstructura,
                                CodigoSondaje = item.CodigoSondaje,
                                CodigoTipoRelleno = item.CodigoTipoRelleno,
                                DescripcionTipoRelleno = ObtenerDescripcionTipoRelleno(item.CodigoTipoRelleno),
                                Orden = item.Orden
                            });
                        }
                        Session[SESSION_ESTRUCTURAS] = listTipoRellenoEstructura;
                    }

                    retorno.result = 1;
                    retorno.message = "OK";
                    retorno.data = Json(obj, JsonRequestBehavior.AllowGet);

                }
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Estructura Controller:Editar", UserLogon.CodigoUsuario, ex);

            }

            return Json(retorno, JsonRequestBehavior.AllowGet);
        }

        protected string ObtenerDescripcionTipoRelleno(int codigoTipoRelleno)
        {
            string descTipoFill = "-";
            try
            {

                using (var proxyTipoFill = new SETipoRellenoClient())
                {
                    var datoTipoR = proxyTipoFill.ObtenerTipoRelleno(codigoTipoRelleno);
                    if (datoTipoR != null) descTipoFill = datoTipoR.Descripcion;
                }

            }
            catch (Exception ex)
            {

                Logger.Error("Estructura Controller:Obtener Descripción", UserLogon.CodigoUsuario, ex);
                //throw ex;


            }

            return descTipoFill;
        }
        //POST: /Muestra /Edit/5
        [HttpPost]
        public ActionResult Edit(int id, FormCollection collection)
        {
            try
            {
                //TODO: Add update logic here

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

        //POST
        /// <summary>
        /// metodo modificar el registro de estructura
        /// </summary>
        /// <param name="entidad"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult Modificar(Estructura entidad)
        {
            Resultado retorno = new Resultado();
            try
            {
                bool flag_exito = true;

                //Modificado por Edgar, la validación debe ser unico para insertar y modificar
                StringBuilder sb = new StringBuilder();
                if (!this.Validar(entidad, ref sb))
                {
                    retorno.result = 0;
                    retorno.message = sb.ToString();
                    flag_exito = false;
                }

                //fin de validaciones insert
                if (flag_exito)
                {
                    var estructura = entidad;
                    using (var proxy = new SEEstructuraClient())
                    {
                        estructura.CodigoGeologo = UserLogon.CodigoGeologo;//Usuario.CodigoGeologo;

                        ///SETTING LISTA ESTRUCTURA TIPO RELLENO
                        listaTipoRelleno = (List<EstructuraTipoRellenoResponse>)Session[SESSION_ESTRUCTURAS];
                        if (listaTipoRelleno != null && listaTipoRelleno.Count > 0)
                        {

                            List<EstructuraTipoRelleno> listTipoRellenoEstructura = new List<EstructuraTipoRelleno>();
                            foreach (EstructuraTipoRellenoResponse item in listaTipoRelleno)
                            {
                                listTipoRellenoEstructura.Add(new EstructuraTipoRelleno
                                {
                                    CodigoEstructura = item.CodigoEstructura,
                                    CodigoSondaje = item.CodigoSondaje,
                                    CodigoTipoRelleno = item.CodigoTipoRelleno,
                                    Orden = item.Orden
                                });
                            }

                            estructura.EstructuraTipoRelleno = listTipoRellenoEstructura.ToArray();
                        }

                        //Modificado por Edgar, el resultado verifica si todo está ok
                        string result = proxy.ModificarEstructura(estructura);
                        if (result.CompareTo("Registrado") != 0)
                        {
                            retorno.result = 0;
                            //retorno.message = Constantes.MensajeEstructura.MSG_INSERT_NO_OK;
                            retorno.message = result;
                            flag_exito = false;
                        }
                        else
                        {
                            retorno.result = 1;
                            retorno.message = Constantes.MensajeEstructura.MSG_EDIT_OK;
                        }

                    }
                }


            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Estructura Controller:Modificar", UserLogon.CodigoUsuario, ex);
            }
            return Json(retorno, JsonRequestBehavior.AllowGet);
        }

        //

        //GET: /Muestra/delete/5

        public ActionResult Delete(int id)
        {
            return View();
        }

        //POST: /Estructura/Delete/5
        /// <summary>
        /// Método para eliminar registro estructura
        /// </summary>
        /// <param name="idSondaje"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult Delete(int idSondaje, int id)
        {
            Resultado retorno = new Resultado();
            // Sondaje obj=null;


            try
            {
                //codigo muestra
                using (var proxy = new SEEstructuraClient())
                {
                    proxy.EliminarEstructura(idSondaje, id);

                    retorno.result = 1;
                    retorno.message = "OK";


                }
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;

            }

            return Json(retorno, JsonRequestBehavior.AllowGet);
        }
        [HttpPost]
        public JsonResult Finalizar(int idSondaje)
        {
            Resultado retorno = new Resultado();
            // Sondaje obj=null;

            try
            {
                //codigo muestra
                string result = string.Empty;
                using (var proxy = new SESondajeClient())
                {
                    result = proxy.FinalizarCumplimiento(idSondaje, enmTipoAnalisis.Estructura.GetHashCode());

                }
                if (result.CompareTo("Cumplido") != 0)
                {
                    retorno.result = 0;
                    retorno.message = result;
                }
                else
                {
                    retorno.result = 1;
                    retorno.message = Constantes.MensajeEstructura.MSG_FINALIZAR_OK;
                }
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = String.Format("Ocurrió un Error{0}", ex.Message);
                Logger.Error("Estructura Controller:Delete", UserLogon.CodigoUsuario, ex);
            }

            return Json(retorno, JsonRequestBehavior.AllowGet);

        }
        [HttpPost]
        public JsonResult addTipoRelleno(int idSondaje, int idEstructura, int idTipoRelleno, string descripcionTipoRelleno)
        {
            Resultado retorno = new Resultado();

            try
            {
                bool flag_exite = true;
                listaTipoRelleno = (List<EstructuraTipoRellenoResponse>)Session[SESSION_ESTRUCTURAS];
                if (listaTipoRelleno == null) listaTipoRelleno = new List<EstructuraTipoRellenoResponse>();
                foreach (var detalle in listaTipoRelleno)
                {
                    if (detalle.CodigoTipoRelleno == idTipoRelleno)// && detalle.CodigoGradoFracturacion == idGradoAlteracion)
                    {
                        //Si encuentra en detalle ya no se agrega
                        flag_exite = false;
                        retorno.message = "Ya se agregó el tipo Relleno";
                        retorno.result = 0;
                    }
                }
                if (flag_exite)
                {
                    EstructuraTipoRellenoResponse item = new EstructuraTipoRellenoResponse();
                    item.Orden = listaTipoRelleno.Count + 1;
                    item.CodigoSondaje = idSondaje;
                    item.CodigoEstructura = idEstructura;
                    item.CodigoTipoRelleno = idTipoRelleno;
                    item.DescripcionTipoRelleno = ObtenerDescripcionTipoRelleno(idTipoRelleno);
                    listaTipoRelleno.Add(item);

                    Session[SESSION_ESTRUCTURAS] = listaTipoRelleno;
                    retorno.message = "";
                    retorno.result = 1;
                }
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Estructura Controller:Agregar Tipo Relleno", UserLogon.CodigoUsuario, ex);

            }
            return Json(retorno, JsonRequestBehavior.AllowGet);


        }
        public JsonResult ListaTipoRellenoNeo()
        {
            listaTipoRelleno = (List<EstructuraTipoRellenoResponse>)Session[SESSION_ESTRUCTURAS];

            if (listaTipoRelleno == null) listaTipoRelleno = new List<EstructuraTipoRellenoResponse>();

            return Json(listaTipoRelleno, JsonRequestBehavior.AllowGet);
        }

        //[HttpPost]
        public JsonResult delTipoRelleno()
        {

            int idTipoRelleno = 0;

            if (Request.QueryString["CodigoTipoRelleno"] != null)
            {
                idTipoRelleno = Convert.ToInt32(Request.QueryString["CodigoTipoRelleno"]);
            }
            Resultado retorno = new Resultado();
            try
            {
                listaTipoRelleno = (List<EstructuraTipoRellenoResponse>)Session[SESSION_ESTRUCTURAS];
                if (listaTipoRelleno != null)
                {
                    EstructuraTipoRellenoResponse objDel = null;
                    foreach (var item in listaTipoRelleno)
                    {
                        if (item.CodigoTipoRelleno == idTipoRelleno)
                        {
                            objDel = item;
                        }
                    }

                    if (objDel != null)
                    {
                        listaTipoRelleno.Remove(objDel);
                    }

                }
                Session[SESSION_ESTRUCTURAS] = listaTipoRelleno;

                retorno.message = "";
                retorno.result = 1;
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Estructura Controller:Eliminar Tipo Relleno", UserLogon.CodigoUsuario, ex);

            }
            return Json(retorno, JsonRequestBehavior.AllowGet);
        }

        [HttpPost]
        public JsonResult obtenerHasta(int idSondaje)
        {
            double hasta = 0.00;
            try
            {

                using (var proxyHasta = new SEEstructuraClient())
                {
                    var datoHasta = proxyHasta.ObtenerUltimoHasta(idSondaje);
                    hasta = datoHasta;
                }

            }
            catch (Exception ex)
            {
                throw ex;

            }

            return Json(hasta, JsonRequestBehavior.AllowGet);
        }
        /// <summary>
        /// ACTION PARA REEMPLAZAR LA GRILLA POR TEMA DE COMPATIBILIDAD - DTM 16072014
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public JsonResult ListarTipoRellenoHtml(string idGrilla)
        {
            Resultado retorno = new Resultado();
            StringBuilder sb = new StringBuilder();
            try
            {
                listaTipoRelleno = (List<EstructuraTipoRellenoResponse>)Session[SESSION_ESTRUCTURAS];
                sb.Append("<div class='k-grid-content' style='height: 118px;'>");
                sb.Append("<table class='k-grid k-widget' style='width: 100%;' >");
                sb.Append("<tr class='k-grid-header'><th class='k-header'>Tipo Relleno</th><th class='k-header'>&nbsp;</th></tr>");
                if (listaTipoRelleno != null)
                {
                    int i = 0;
                    string alt = "";
                    foreach (var item in listaTipoRelleno)
                    {
                        if (i % 2 == 1)
                            alt = " class='k-alt' ";
                        else
                            alt = "";
                        sb.AppendFormat("<tr {0} ><td>{1}</td>", alt, item.DescripcionTipoRelleno);
                        //string idGrilla = item.CodigoEstructura == 0 ? "#gridTipoRelleno" : "#gridTipoRellenoEdit";
                        sb.AppendFormat("<td><a class='k-button k-button-icontext k-grid-delete' href=javascript:delTipoRellenoHtml('{0}','{1}'); > <span class='k-icon k-delete'></span>Delete</a></td></tr>", item.CodigoTipoRelleno, idGrilla);
                        i++;
                    }

                }
                sb.Append("</table>");
                sb.Append("</div>");
                retorno.result = 1;
                retorno.message = sb.ToString();
            }
            catch (Exception ex)
            {
                retorno.result = 0;
                retorno.message = ex.Message;
                Logger.Error("Estructura Controller:ListarTipoRellenoHtml", UserLogon.CodigoUsuario, ex);

            }
            return Json(retorno, JsonRequestBehavior.AllowGet);
        }
    }
}